1. Field of the Invention
The present invention generally relates to legacy systems and, more specifically, the present invention provides a system and method for legacy system component incremental migration.
2. Related Art
Software systems are evolutionary in that they typically change over time. These changes can be minor and don't require any considerable effect. Or, they can be major which causes the schema to change and consequently precipitates a major migration effect to move the legacy system to the new system. Of course, as is well-known, a legacy system is an old computer system or application program which continues to be used because the user (typically an organization) does not want to replace or redesign it. The software system may be a tool which manages compilation of a programming language or, alternatively, it could be a database schema which is changing to a new version. One example of a programming tool is a UML development environment that is focused on creating artifacts based on the UML 1.4 specification. In the field of software engineering, the Unified Modeling Language (UML) is a standardized specification language for object modeling. UML is a general-purpose modeling language that includes a graphical notation used to create an abstract model of a system, referred to as a UML model. UML is officially defined at the Object Management Group (OMG) by the UML metamodel, a Meta-Object Facility metamodel (MOF). Like other MOF-based specifications, the UML metamodel and UML models may be serialized in XML. UML was designed to specify, visualize, construct, and document software-intensive systems. A new system could be new version of the development environment that is based on the UML 2.0 specification.
Using this example, although there is a mapping from the UML 1.4 to 2.0 specifications, the schemas are different enough that there is no backwards compatibility and a concentrated import must be performed in order for the UML 1.4 artifacts to be converted to UML 2.0. The same paradigm could be applied to databases, where the tooling environment manages a particular database version and a new database version schema is introduced that are not backward compatible with the previous version.
An artifact is one of many kinds of tangible byproduct produced during the development of software. Some artifacts, e.g., use cases, class diagrams, and other UML models, requirements and design documents help describe the function, architecture, and design of software. “Artifact” is most commonly used in referring to the byproducts of software development rather than the product itself. The sense of artifacts as byproducts is similar to the use of the term artifact in science to refer to something that arises from the process in hand rather than the issue itself, i.e., concerned with the means rather than the end.
Often, migration from a legacy system to a new system is tackled in a “Big-Bang” theory of operation as shown in FIG. 3. This means simply that the legacy system 316 is shut-down (“Stop Development” 314) and migrated all at once to the new system using tools to convert any relevant artifacts (steps 304, 306) to the format understood by the new system 318. Realistically though, the legacy system 316 is usually kept in production for maintenance purposes and is still required while verification (step 308) of the new system 318 is in process.
FIG. 3 illustrates two partitions of workflow, one for the legacy system 316 and one for the new system 318. First, the legacy system data is prepared for the migration (step 304) which may entail some clean-up or refactoring then it is imported (step 306) through a filter/transformation mechanism into the new system 318.
From there, the content is usually verified and tested to ensure system integrity before it can be brought back into production (step 308). During this time, the legacy system is shut-down and not available (step 314). After the migration, the legacy system 316 may be brought back up for read-only access or to support data streams not being migrated to the new system (step 315). This system stoppage can be costly to an organization since it implies that the system is not processing data during this time. Very often, the data transformation can run into unforeseen issues which cause it to take longer than predicted which of course makes the system stoppage even more costly.
System software architecture is usually divided into components that represent different aspects or functionality within the system. (Alternatively, they can be hardware components which are generally faster but updating them is more difficult and more expensive.) The components depend on each other in a layered fashion where the core components are at the bottom of the dependency chain and the leaf or product components are at the top. The core components by their nature are reusable across different product level components and are critical to the execution of the system. Different product components may have different release cycles that require them to have schedules which aren't in sync. Since they may depend on the same core components, one product stack may be ready to migrate to the new system, but other product stack or stacks may not be ready due to schedule or release concerns. This means that the core components are by nature synchronized with the slowest moving product stack since the core components have to support all dependent components above them. Consequently the core components are generally not ready to migrate at the same time as the more progressive product components at the top of the dependency chain.
In the above example, as shown in FIG. 4, all of the product (leaf) components (“<<component>>”) depend on “Core 1” 408. If “Product 3” 410 is ready to migrate, but “Product 1” 404 is not, “Product 3” 410 must wait for “Product 1” 404 to be at an appropriate stage in order for migration to proceed. The reason for this is that they are both dependent on “Core 1” 408.
It is perhaps naive to think that once the migration to the new system is complete, the legacy system will no longer be needed. In an ideal situation, the data can be 100% migrated and there is no longer a need to support the data or a subset of data on the legacy system. This will probably not happen often. If the legacy system is supporting a particular release of software, then it would need to support that release for its lifecycle. It would be too risky to release the software from the legacy system and immediately migrate it to the new system and subsequently support bug fixes. Issues from the field would not map directly into the new system and migrating data in a fix-pack which is supposed to address particular issues is foolhardy at best. This implies that the legacy system and new system need to co-exist for a period of time, which could be considerable depending on release schedules. Fixes or changes in data/software on the legacy side need to be propagated into the new system. If the differences between the data structure are considerable between the two systems, then a file system merge is not sufficient. (Merging is the act of reconciling multiple changes made to different copies of the same file for instance, by performing an automated difference analysis between two files and considering the differences between the two files alone to conduct the merge and makes a “best-guess” analysis to generate the resulting merge. Sometimes, merging requires user intervention to verify and sometimes correct the result of the merge prior to completing the merge event.) Generally, required changes would need to be integrated manually through code or data inspection for accuracy purposes.
Therefore, there exists a need for a solution that solves at least one of the deficiencies of the related art.